#include <iostream>
using namespace std;

/*
    系统性地总结公有继承子类究竟可以使用父类的哪些成员
    1.全面系统--》父类三种权限全部写满
    2.站在两个角度研究
      角度1：站在子类的外部
      角度2：站在子类的内部

    3.子类继承了父类，子类究竟可以使用父类的哪些成员
          公有继承：                             公有成员                   保护成员                 私有成员
                 情况一：在子类的外部               ok                         NO                       NO
                 情况二：在子类的内部               ok                         ok                       NO
          保护继承：                             公有成员                   保护成员                 私有成员
                 情况一：在子类的外部               NO                         NO                       NO
                 情况二：在子类的内部               ok                         ok                       NO
          私有继承：                             公有成员                   保护成员                 私有成员
                 情况一：在子类的外部               NO                         NO                       NO
                 情况二：在子类的内部               ok                         ok                       NO
          绝大部分情况都采用公有继承

    1）public继承方式
    1.基类中所有public成员在派生类中为public属性；
    2.基类中所有protected成员在派生类中为protected属性；
    3.基类中所有private成员在派生类中不能使用。
    2)protected继承方式
    1.基类中的所有public成员在派生类中为protected属性；
    2.基类中的所有protected成员在派生类中为protected属性；
    3.基类中的所有private成员在派生类中不能使用。
    3)private继承方式
    1.基类中的所有public成员在派生类中均为private属性；
    2.基类中的所有protected成员在派生类中均为private属性；
    3.基类中的所有private成员在派生类中不能使用。
*/

class Animal
{
public:
    void eat()
    {
        cout << "animal eat" << endl;
    }
    int age;

private:
    void sleep()
    {
        cout << "animal sleep" << endl;
    }
    int weight;

protected:
    void run()
    {
        cout << "gogogo 出发咯~" << endl;
    }
    int height;
};

class Cat : public Animal
{
public:
    void fun()
    {
        // 子类的内部: 子类对象可以使用父类的所有共有成员和保护成员
        eat();
        age = 100;
        run();
        height = 10;
    }
};

class Dog : private Animal
{
public:
    void fun()
    {
        // 子类的内部: 子类对象可以使用父类的所有共有成员和保护成员
        eat();
        age = 100;
        run();
        height = 10;
    }
};

class Pig : protected Animal
{
public:
    void fun()
    {
        // 子类的内部: 子类对象可以使用父类的所有共有成员和保护成员
        eat();
        age = 100;
        run();
        height = 10;
    }
};

int main()
{

    // ----------------公有继承--------------------
    Cat c;

    // 子类的外部，子类对象可以使用父类的所有公有成员
    c.eat();
    c.age = 10;

    // 子类的外部，子类对象不可以使用父类的私有成员
    // c.sleep();
    // c.weight = 10;

    // 子类的外部，子类对象不可以使用父类的保护成员
    // c.run();
    // c.height = 10;

    c.fun();

    // ----------------私有继承--------------------
    // 子类的外部，子类对象不可以使用父类的任何成员

    // Dog d;

    // d.eat();
    // d.age = 10;

    // d.sleep();
    // d.weight = 10;

    // d.run();
    // d.height = 10;

    // d.fun();

    // ----------------保护继承--------------------
    // 子类的外部，子类对象不可以使用父类的任何成员

    // Pig p;

    // p.eat();
    // p.age = 10;

    // p.sleep();
    // p.weight = 10;

    // p.run();
    // p.height = 10;

    // p.fun();

    return 0;
}